Podstawowe typy danych w Javie

Typy prymitywne, tablice, łańcuchy znaków oraz typ wyliczeniowy

dr inż. Aleksander Smywiński-Pohl

apohllo@agh.edu.pl

http://apohllo.pl/dydaktyka/programowanie-obiektowe

konsultacje: wtorek 15:30 - 18:00, pokój 4.61

Typy prymitywne

• boolean - wartości true i false
• char - pojedyncze znaki z zestawu Unicode
• byte - jednobajtowa liczba ze znakiem
• short - dwubajtowa liczba ze znakiem
• int - czterobajtowa liczba ze znakiem
• long - ośmiobajtowa liczba ze znakiem
• float - liczba zmiennopozycyjna, co najmniej 6 cyfr znaczących
• double - liczba zmiennopozyzyjna, co najmniej 15 cyfr znaczących

Charakterystyczne jest, że liczby całkowite nie występują w wersji bez znaku.

Typ boolean

int invalidValue = 1;
if(invalidValue) {                                  
    System.out.println("Wycieraczki są włączone");
} else {
    System.out.println("Wycieraczki są wyłączone");
}

boolean wipersOn = true;
if(wipersOn) {
    System.out.println("Wycieraczki są włączone");
} else {
    System.out.println("Wycieraczki są wyłączone");
}

Jedyny typ, który może pojawić się w warunku logicznym. Nie ma konwersji między typami liczbowymi a typem logicznym.

Typ char

import static java.lang.System.out;

char driverCategory = 'ś';
char tick = '\u2713';
out.println(driverCategory);
out.println(tick);
out.println(Character.isLetter(driverCategory));
out.println(Character.isLetter(tick));

Pojedyncze znaki umieszczane są w pojedynczym cudzysłowie. Wewnętrznie wykorzystywany jest zestaw znaków Unicode. Można wprowadzać znaki bezpośrednio oraz używając składni \u..... Ta druga pozwala wprowadzać dowolny znak należący do zestawu. Znaki nie są obiektami, dlatego nie można wywoływać na nich metod. Żeby testować ich własności konieczne jest wykorzystanie metod statycznych klasy Character.

Dodatkowo w powyższym kodzie dla wygody zaimportowaliśmy pole out z klasy System dzięki czemu kod stał się nieco krótszy.

Typy całkowitoliczbowe: byte, short, int oraz long

typ	liczba bajtów	wartość minimalna	wartość maksymalna
byte	1	-128	127
short	2	-32 768	32767
int	4	-2 147 483 648	2 147 483 647
long	8	-9 223 372 036 854 775 808	9 223 372 036 854 775 807

int a = 10;
int b = 20;
long c = a + b;
//short d = a + b;
short e = (short) (a + b);
System.out.println(e);

int a = 10;
int b = 20;
int e;
if(Short.MAX_VALUE > a + b){
    e = (short) (a + b);
}
byte f = 127;
byte g = 127;
byte h = (byte) (f + g);
System.out.println(h);

W typach całkowitoliczbowych mamy do czynienia z automatyczną promocją typu. Polega ona na tym, że wartość typu o mniejszym zakresie może być przypisana do zmiennej typu o szerszym zakresie. Działanie w drugą stronę nie może być wykonane niejawnie - konieczne jest rzutowanie wartości. Oczywiście taka operacja jest ryzykowna i powinna być ograniczona odpowiednim warunkiem. Przekroczenie wartości maksymalnej nie jest sygnalizowane w żaden sposób. Wartość jest obcinana do bitów, które mieszczą się w danej reprezentacji.

Typy zmiennopozycyjne float i double

typ	liczba bajtów	cecha (bity)	mantysa (bity)
float	4	8	23
double	8	11	52

import static java.lang.System.out;

int a = 0;
float b = 0.0f;

if(a == b){
    out.println("Wartości są identyczne");
}

import static java.lang.System.out;

float a = 0.0f;
float b = 0.001f;
for(int i=0; i < 1000; i++){
    a += b;
}
if(a == 1.0){
    out.println("Wartości są identyczne");
} else {
    out.println("Wartości nie są identyczne");
}

import static java.lang.System.out;

float a = 0.0f;
float b = 0.001f;
double EPSILON = 1e-5;

for(int i=0; i < 1000; i++){
    a += b;
}
if(Math.abs(a - 1) < EPSILON){
    out.println("Wartości są prawie identyczne");
} else {
    out.println("Wartości nie są prawie identyczne");
}

Wartości zmiennopozycyjne można zapisywać w notacji "tradycyjne" oraz "inżynierskiej" (z "e", który określa wykładnik potęgi o podstawie 10, do której podnoszona jest wartość). Pomimo różnicy typu, porównywane wartości są identyczne. W praktyce jednak należy korzystać z drugiego sposobu, zawsze kiedy mamy do czynienia z wartościami zmiennoprzecinkowymi.

Typy otokowe

• Boolean
• Byte
• Short
• Character
• Integer
• Long
• Float
• Double

Opakowują typu prymitywne

Integer a = new Integer(10);
Integer b = new Integer(20);
Integer c = a + b;
System.out.println(c.toString());

int d = 30;
out.println(d.toString());

No typach prymitywnych nie można wywoływać metod.

Zastosowanie typów otokowych

import java.util.*;

List<Integer> list = new LinkedList<Integer>();
list.add(new Integer(10));
list.add(new Integer(20));

System.out.println(list);

// Autoboxing
import java.util.*;

List<Integer> list = new LinkedList<Integer>();

list.add(30);
list.add(40);

System.out.println(list);

Porównywanie typów otokowych

import static java.lang.System.out;

Integer a = 200;
Integer b = 200;
if(a == b){ 
    out.println("Wartości są równe");
} else {
    out.println("Wartości nie są równe");
}

import static java.lang.System.out;

Integer a = 200;
Integer b = 200;

if(a == b){ 
    out.println("Wartości są równe");
} else {
    out.println("Wartości nie są równe");
}

if(a.equals(b)){ 
    out.println("Wartości są równe");
} else {
    out.println("Wartości nie są równe");
}

Typ tablicowy

import static java.lang.System.out;

int[] speedVector = new int[3];
speedVector[0] = 10;
speedVector[2] = -3;

for(int i = 0; i < 4; i++){
    out.println("Składowa " + (i + 1) + " wektora wynosi: " + speedVector[i]);
}

Tablice mogą składać się z elementów typów prymitywnych oraz obiektów. Tablice są obiektami, zatem tworzy się je za pomocą słowa kluczowego new. W trakcie inicjacji trzeba określić rozmiar tablicy i jest on niezmienny przez cały czas działania programu. Dostęp do składowych odbywa się analogicznie jak w języku C. Niezainicjowane wartości mają przypisaną wartość domyślną (np. 0 dla typów całkowitych). Przekroczenie zakresu skutkuje wystąpieniem wyjątku ArrayIndexOutOfBoundsException. Nie ma więc niebezpieczeństwa odczytu wartości spoza dopuszczalnego zakresu.

Typ tablicowy - obiekty

class Speed {
    public int value;
    public String unit;

    public Speed(int value, String unit){
        this.value = value;
        this.unit = unit;
    }
}

Klasa Speed będzie wykorzystywana jeszcze w dalej - wrócimy do niej na kolejnym wykładzie.

Typ tablicowy - obiekty

import static java.lang.System.out;

Speed[] speedVector = new Speed[3];
speedVector[0] = new Speed(10, "km/h");
speedVector[1] = new Speed(-3, "km/h");

for(int i = 0; i < 3; i++){
    out.println("Składowa " + (i + 1) + " wektora wynosi: " + 
        speedVector[i].value + " " + speedVector[i].unit);
}

Tablica typu referencyjnego również jest inicjowana - ale specjalną wartością pustą null. Jeśli jakiś element nie zostanie zainicjowany (tutaj element o indeksie 2), to ma on wartość null. Próba odczytania wartości takiego obiektu skutkuje wystąpieniem wyjątku NullPointerException. Jest to najczęstszy wyjątek, z którym ma do czynienia każdy programista Javy.

Zabezpieczenie przed wyjątkiem NullPointerException

import static java.lang.System.out;

Speed[] speedVector = new Speed[3];
speedVector[0] = new Speed(10, "km/h");
speedVector[1] = new Speed(-3, "km/h");

for(int i = 0; i < 3; i++){
    if(speedVector[i] == null) {
        out.println("Składowa " + (i + 1) + " wektora jest pusta");
    } else {
        out.println("Składowa " + (i + 1) + " wektora wynosi: " + 
            speedVector[i].value + " " + speedVector[i].unit);
    }
}

Możemy np. porównać wartość, którą chcemy wykorzystać z wartością pustą za pomocą operatora ==. Jeśli wartość jest pusta możemy na przykład poinformować o tym użytkownika. Oczywiście właściwe rozwiązanie będzie zależało od pisanej aplikacji. Czasami wartość pusta oznacza błąd w kodzie programu, który musimy naprawić. Zasadniczo warto sprawdzać niepustość zmiennych referenyjnych, gdyż może to istotnie poprawić odporność naszego kodu na błędy. Ponadto każdy komunikat jest lepszy niż niewiele mówicy wyjątek NullPointerException. Więcej na ten temat zostanie przedstawione na wykładzie dotyczącym wyjątków.

Alternatywna pętla for

import static java.lang.System.out;

Speed[] speedVector = new Speed[3];
speedVector[0] = new Speed(10, "km/h");
speedVector[1] = new Speed(-3, "km/h");

for(Speed element : speedVector) {
    if(element == null) {
        out.println("Składowa wektora jest pusta");
    } else {
        out.println("Składowa wektora wynosi: " + 
            element.value + " " + element.unit);
    }
}

Java posiada alternatywną składnię dla pętli for, która pozwala na wygodniejsze iterowanie po elementach talic (i nie tylko tablic). Charakterystycznym elementem tej składni jest to, że wykorzystuje ona zmienną lokalną i przypisuje do niej kolejne wartości znajdujące się w tablicy. Niestety w typ przypadku nie mamy dostępu do indeksu elementu.

Porównywanie tablic

import static java.lang.System.out;

int[] speedVector1 = { 10, -3, 0 };
int[] speedVector2 = { 10, -3, 0 };

if(speedVector1 == speedVector2){
    out.println("Wektory są równe");
} else {
    out.println("Wektory nie są równe");
}

import static java.lang.System.out;

int[] speedVector1 = { 10, -3, 0 };
int[] speedVector2 = { 10, -3, 0 };
if(speedVector1.equals(speedVector2)){
    out.println("Wektory są równe");
} else {
    out.println("Wektory nie są równe");
}

import static java.lang.System.out;
import java.util.*;

int[] speedVector1 = { 10, -3, 0 };
int[] speedVector2 = { 10, -3, 0 };
if(Arrays.equals(speedVector1, speedVector2)){
    out.println("Wektory są równe");
} else {
    out.println("Wektory nie są równe");
}

Wartości typów prostych porównuje się za pomocą operatora ==, natomiast wartości typów referencyjnych za pomocą metody equals (o ile została ona zaimplementowana). Niestety w przypadku tablic musimy skorzystać z zewnętrznej funkcji equals, która najduje się w klasie pomocniczej Arrays.

Sortowanie i wypisywanie tablic

import static java.lang.System.out;
import java.util.*;

int[] vector = { 7, 15, 10, -3, 9, 12};
Arrays.sort(vector);
out.println(vector.toString());
out.println(Arrays.toString(vector));

Klasa Array również nie ma zaimplementowanej metody sort, a metoda toString daje wynik, który jest mało zadowalający. W obu przypadkach konieczne jest wykorzystanie zewnętrznych procedur pomocniczych zdefiniowanych w klasie Arrays.

Tablice wielowymiarowe

import static java.lang.System.out;

int[][] matrix1 = new int[10][10];
out.println(matrix1[0][0]);

import static java.lang.System.out;

int[][] matrix2 = new int[10][];
//out.println(matrix2[0][0]);

for(int i = 0; i < 10; i++){
    matrix2[i] = new int[10];
}
out.println(matrix2[0][0]);

Tablice wielowymiarowe można inicjować na dwa sposoby: albo podając od razu wszystkie wymiary, albo podając jedynie n-pierwszych wymiarów. W pierwszym przypadku otrzymujemy tablicę zainicjowaną wartościami domyślnymi dla danego typu. W drugim przypadku zainicjowanych jest tylko n-pierwszych wymiarów i w takiej tablicy występują wartości null. Dlatego trzeba "ręcznie" zainicjować pozostałe wymiary.

Porównywanie i wyświetlanie tablic wielowymiarowych

import static java.lang.System.out;
import java.util.*;

int[][] matrix1 = { {1, 2}, 
                    {3, 4} };
int[][] matrix2 = { {1, 2}, 
                    {3, 4} };
               
out.println(Arrays.toString(matrix1));

import static java.lang.System.out;
import java.util.*;

int[][] matrix1 = { {1, 2}, 
                    {3, 4} };

out.println(Arrays.deepToString(matrix1));

import static java.lang.System.out;
import java.util.*;

int[][] matrix1 = { {1, 2}, 
                    {3, 4} };
int[][] matrix2 = { {1, 2}, 
                    {3, 4} };

if(Arrays.equals(matrix1,matrix2)){
    out.println("Tablice są równe");
} else {
    out.println("Tablice **nie** są równe");
}

import static java.lang.System.out;
import java.util.*;

int[][] matrix1 = { {1, 2}, 
                    {3, 4} };
int[][] matrix2 = { {1, 2}, 
                    {3, 4} };

if(Arrays.deepEquals(matrix1,matrix2)){
    out.println("Tablice są równe");
} else {
    out.println("Tablice **nie** są równe");
}

Niestety metody Arrays.toString() oraz Arrays.equals() nie działają na tablicach wielowymiarowych. Konieczne jest wykorzystanie wersji deepToString() oraz deepEquals.

Łańcuchy znaków

import static java.lang.System.out;

String unit1 = "km/h";
String unit2 = "km/h";

if(unit1 == unit2){
    out.println("Jednostki są równe");
} else {
    out.println("Jednostki **nie** są równe");
}

import static java.lang.System.out;

String unit1 = "km/h";
String letter = "h";
String unit2 = "km/"  + letter;

if(unit1 == unit2){
    out.println("Jednostki są równe");
} else {
    out.println("Jednostki **nie** są równe");
}

import static java.lang.System.out;

String unit1 = "km/h";
String letter = "h";
String unit2 = "km/"  + letter;

if(unit1.equals(unit2)){
    out.println("Jednostki są równe");
} else {
    out.println("Jednostki **nie** są równe");
}

Hmm, to jest bardzo piękny przykład. Zasadniczo łańcuchy znaków zawsze porównujemy za pomocą metody equals. Ale pokazanie dlaczego jest to konieczne, nie jest zbyt proste. W pierwszym przypadku mamy dwie zmienne, które wskazują na dokładnie ten sam obiekt, ponieważ na etapie kompilacji oba łańcuchy są identyczne i Java optymalizuje ten przypadek tak, by zajmowane było mniej pamięci. Natomiast trzeci łańcuch jest konstruowany w trakcie wykonania programu. Dlatego jest on osobnym obiektem i porównanie == daje w wyniku false. Podsumowując - do porównywania obiektów (z wyjątkiem tablic) używamy zawsze metody equals.

Modyfikacja łańcuchów

import static java.lang.System.out;

String km = "km";
String divider = "/";
String hour = "h";

String unit1 = "";
String unit2 = unit1;
unit1 += km;
unit1 += divider;
unit1 += hour;

if(unit1 != unit2){
    out.println("Łańcuchy nie są równe");
}

Łańcuchy można "modyfikować", za pomocą operatora konkatenacji (+), ale w praktyce, ponieważ w Javie łańcuchy są niezmienne, oznacza to zawsze utworzenie nowego łańcucha. Z tego względu jeśli łańcuch jest wielokrotnie modyfikowany, to powstaje wiele obiektów, które muszą być obsłużone przez Garbage collectora (śmieciarza). Ponadto tak "zmodyfikowany" łańcych nie równa się (w sensie referencji) oryginalnemu łańcuchowi.

import static java.lang.System.out;

String km = "km";
String divider = "/";
String hour = "h";

StringBuilder builder1 = new StringBuilder();
StringBuilder builder2 = builder1;
builder1.append(km);
builder1.append(divider);
builder1.append(hour);

if(builder1 == builder2){
    out.println("Fabryki łańcuchów są równe");
}

out.println(builder1.toString());

W sytuacji modyfikowania (budowania) łańcucha lepiej wykorzystać klasę StringBuilder. Dzięki metodzie append można doklejać kolejne fragmenty, co jest znacznie bardziej wydajne, a ponadto oryginalny budwoniczy jest tożsamy z budowniczym po modyfikacjach. Aby uzuskać efekt końcowy trzeba wywołać metodę toString(). Metoda ta jest zdefiniowana dla wszystkich klas i jej celem jest uzyskanie reprezentacji obiektu w postaci łańcucha znaków. Dzięki temu można np. wyświetlić go w konsoli.

Typ wyliczeniowy

import static java.lang.System.out;
import java.time.DayOfWeek;
import java.util.*;

/*
enum DayOfWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    ...
}
*/

DayOfWeek day = DayOfWeek.TUESDAY;
out.println(day.name());
out.println(day.ordinal());
out.println(Arrays.toString(DayOfWeek.values()));

Typ wyliczeniowy jest wykorzystywany do definiowania wartości, które należą do niewielkiego zbioru. Należy pamietać, że nowe wartości mogą być dodawane na końcu - w przeciwnym razie wartości liczbowe odpowiadające nazwom zostaną zmienione.

Instrukcja selekcji i typ wyliczeniowy

import static java.lang.System.out;
import java.time.DayOfWeek;

DayOfWeek day = DayOfWeek.TUESDAY;

switch(day){
    case MONDAY:
        out.println("Jak ja nie lubię poniedziałków!");
        break;
    case TUESDAY:
        out.println("No, wreszcie wykład z TO!");
        break;
    case WEDNESDAY:
        out.println("Płaska środa");
        break;
}

Instrukcja może być wygenerowane przez IDE.

Instrukcja selekcji i łańcuchy znaków

import static java.lang.System.out;
String day = "teusday";

switch(day){
    case "monday":
        out.println("Jak ja nie lubię poniedziałków!");
        break;
    case "tuesday":
        out.println("No, wreszcie wykład z TO!");
        break;
    case "wednesday":
        out.println("Płaska środa");
        break;
}

Od Javy 7. Łatwo o pomyłkę - w przykładzie jest literówka.

Porównywanie wartości typu wyliczeniowego

import static java.lang.System.out;
import java.time.DayOfWeek;

DayOfWeek day1 = DayOfWeek.MONDAY;
DayOfWeek day2 = DayOfWeek.MONDAY;

if(day1 == day2){
    out.println("Dni są równe");
}

http://kahoot.it

https://goo.gl/forms/GMwj6A8843qOp4sg2